feat(sync): add the TypeScript and JavaScript adapters - #992

TypeScript export-equals is ignored

Medium Severity

import x = require(...) is bound as a namespace and as the default, but the matching TypeScript export export = value is never read. typeScriptDefaultExport only looks for export default, and typeScriptExportedNames only records export const / export { ... } and module.exports. A CJS file that uses export = TEXT or export = { TEXT } therefore has no importable constants, so a require or import-equals of that module stays unresolved.

 

^{Reviewed by Cursor Bugbot for commit ddadedd. Configure here.}

Fixed. typeScriptModuleExports reads export = value through typeScriptExportEquals as it reads module.exports = value: an object exports its entries, an identifier or a literal exports the whole module, and a literal declares the default. typeScriptConstants now collects these exports before it handles export default. TestTypeScriptExportEqualsIsImportable covers export = TEXT, export = { TEXT }, and export = "text" through import x = require(...).

Constructor this-assignment drops client kind

Medium Severity

Assigning a constructor parameter onto this, such as this.client = client, records an empty instance kind and can wipe a real client binding. JavaScript has no parameter properties, so the usual constructor pattern never tags this.client, and later this.client.chat.completions.create(...) (and the Anthropic equivalent) is missed. TypeScript only works when the parameter uses an accessibility modifier.

 

^{Reviewed by Cursor Bugbot for commit 4b811ce. Configure here.}

Fixed. When a constructor stores a parameter on this, typeScriptInstances reads the type of the parameter: client: OpenAI tags the property with the client kind, and a parameter without a type records nothing, so it does not wipe the kind that a field gave the property. TestTypeScriptConstructorParametersKeepTheClientKind covers a typed TypeScript parameter and a plain JavaScript parameter over a field.

Namespace mutation misses named imports

Medium Severity

A write through a namespace import records values.LIST, and the freeze pass only marks that namespace field. A named import of the same export stays writable, and the reverse is also true. At runtime those bindings are one value, so sync can still emit edits for an export that the file already mutated.

 

^{Reviewed by Cursor Bugbot for commit 9a6741a. Configure here.}

Fixed. typeScriptSpreadImportMutations links a named import and the field of a namespace import that hold one export, by the shared value, and spreads a mutation through either name to both before the freeze pass. TestTypeScriptNamedAndNamespaceImportsShareMutations covers a push through the named import, a push through the namespace, and an untouched export that stays writable through both names.

Static field scopes omit static marker

Medium Severity

The static scope marker is applied only to method_definition, so a static field initializer shares ids with an instance field of the same name. Locals in a static field arrow are treated as reassigned, and agents or tools stored on the field get positional ids instead of a stable Class.static.field key.

 

^{Reviewed by Cursor Bugbot for commit c5bc94d. Configure here.}

Fixed. typeScriptStaticScope applies the static marker to a static method and to a function or class that initializes a static field, so a static field arrow has the scope Class.static.field and an instance field of the same name is another scope. TestTypeScriptStaticFieldInitializersAreScopesOfTheClass covers a static and an instance field arrow with one name and one local.

Typed parameter properties skip client kinds

Medium Severity

constructor(private client: OpenAI) never records a client kind. typeScriptBinding returns that parameter with no value, and typeScriptInstances then drops every nil value before typeScriptParameterKind can read the annotation. Methods that call this.client.chat.completions.create(...) or this.client.messages.create(...) are therefore not collected. The covered form is only a parameter property with a new OpenAI() default, which is not the usual TypeScript injection pattern.

 

^{Reviewed by Cursor Bugbot for commit 45f1733. Configure here.}

Fixed. typeScriptInstances records a parameter property without a value, such as constructor(private client: OpenAI), with the kind that its type names, through typeScriptParameterKind, so this.client.chat.completions.create(...) in a method is collected. TestTypeScriptTypedParameterPropertiesAreClients covers an OpenAI and an Anthropic parameter property next to a string one.

CJS object export misses default import

Medium Severity

A default import of a CommonJS module that assigns an object to module.exports (or export = { ... }) stays unresolved. Named keys become exports, but the object itself is never recorded as * or default, so the interop fallback never runs. require and import * as still work; import x from "./mod" and x.field do not, which is the usual esModuleInterop shape.

 

^{Reviewed by Cursor Bugbot for commit 2480e2e. Configure here.}

Fixed. module.exports = { ... } and export = { ... } mark the object as the module, so the import resolution binds the named exports as one object for the * binding and the default import, as require already did. An entry named default replaces the marker. TestTypeScriptDefaultImportOfACommonJSObjectModule covers both forms through import x from and x.field.

Static clients ignored on class name

Medium Severity

A static client field is stored as Class.static.client, and this.client inside a static method finds it. A call through the class name, such as Class.client.chat.completions.create(), never inserts the static marker, so the receiver has no kind and the request is dropped. Constant reads and mutations through that same class name already insert the marker.

 

^{Reviewed by Cursor Bugbot for commit 2480e2e. Configure here.}

Fixed. typeScriptInstanceKind tries the receiver with the static marker after the class name, Bot.static.client for Bot.client, as a constant read through the class name does, so a request through the class name finds the static client inside and outside the class. TestTypeScriptStaticClientsResolveThroughTheClassName covers both.

Parameter types miss type-only imports

Medium Severity

typeScriptParameterKind looks up a parameter’s type in the value-import map, which skips import type and { type X } bindings, and it only accepts a bare identifier. Typed parameter properties and this.client = client therefore get no client kind for import type OpenAI from "openai" or client: OpenAI | undefined, so this.client.chat.completions.create(...) is not collected. Those forms are the usual TypeScript shape under verbatimModuleSyntax.

 

^{Reviewed by Cursor Bugbot for commit 2cc09c6. Configure here.}

Fixed. The instances read parameter types through typeScriptTypeImports, which keeps the type-only bindings of import type and { type X } that the value imports leave out, and typeScriptParameterKind finds the one type of the annotation that an import binds, so client: OpenAI | undefined and client?: OpenAI name the kind. TestTypeScriptTypeOnlyImportsNameParameterKinds covers a type-only default import with a union type and a type-only named import stored on this.

Locals fail to shadow outer constants

Medium Severity

typeScriptConstants only records a variable when it is a simple identifier with an initializer, so destructuring, for/of targets, and uninitialized let never hide an outer constant of the same name. A use of that name then reads the import or module binding instead of the local, and a write can edit the wrong file. Parameters already get a nil shadow, and the import-alias walk already uses bound names for these forms.

 

^{Reviewed by Cursor Bugbot for commit 4a3d440. Configure here.}

Fixed. The declaration walk records a destructuring, an uninitialized let or const, and a for-of or for-in target as bindings without a value, in their block, so a use of the name reads the local instead of an outer constant or import. TestTypeScriptLocalsOfEveryFormHideOuterConstants covers all three forms next to a module use that still resolves.

Anonymous classes break this.client lookup

Medium Severity

typeScriptClassScopes skips a class with no scope name before it can mark inClass, so this.client in a method of an anonymous class is keyed under the method while the field client = new OpenAI() is not. Mixin factories and export default class { ... } then miss the client and drop the request.

 

^{Reviewed by Cursor Bugbot for commit 74de14c. Configure here.}

Fixed. typeScriptScopeName gives an anonymous class a name of its own from its position, so typeScriptClassScopes marks the class and a field and a method of export default class {} or of a mixin class share one scope, and this.client finds the field. TestTypeScriptAnonymousClassesKeepTheirClients covers a default export class and a mixin factory.

Class name resolves instance over static

High Severity

typeScriptInstanceKind looks up Bot.client as a bare scoped name before trying Bot.static.client. An instance field uses the id Bot.client, so that hit wins and the static fallback never runs. In JavaScript, Bot.client is the static member; the instance field is this.client. A request through the class name can bind the instance client, or miss the static one, whenever both fields share a name. Constant reads and mutation tracking already try the static marker first.

 

^{Reviewed by Cursor Bugbot for commit f38c0d4. Configure here.}

Fixed. typeScriptInstanceKind tries the static marker first for a dotted receiver whose root is not this, so Bot.client reads the static field even when an instance field has the same name, and this.client reads the instance field, as a constant read through the class name already did. TestTypeScriptClassNameReadsTheStaticClientFirst covers a class with both fields.